ISU Ov10

Del 1
Copy constructor og asignment operator er gjort private da vi ikke ønsker at andre skal tilgå dem og ædre på str_.

#ifndef SMARTSTRING_H
#define SMATSTRING_H
#include <string>
using namespace std;
 
class SmartString
{
public:
  SmartString(string* str):str_(str){}
  ~SmartString()
  {
    delete str_;
  }
  string* get()
  {
     return str_;
  }
  string* operator->()
  {
    return str_;
  }
  string& operator*()
  {
    return *str_;
  }
 
private:
  /*Erklære copy construntor
   * og assignment
   * private, da vi ikke vil have andre til at pille ved copy og point
   */
  string* str_;
  SmartString(const SmartString& other){}
  SmartString* operator=(const SmartString& other){}
};
 

What exactly does the operator ->() do?
Den gør at vi kan tilgå funktioner som er i string i stedet for at tilgå medlemsfunktionerne som er i vores klasse

VEd hjælp af RAII kan vi sikre den dynamiske allokering og dermed kan vi få SMartString til at fremstå som en raw pointer ved at overloade. Man kan dermed bruge SmartString på de steder hvor vi ville forvænte at der er en raw pointer.

Til hjælp blev benyttet "
http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Smart_Pointer" ud fra denne er selve opbygning og besvarelse gjort

Del 2
Vi implementere nu en counter i vores Smart pointer fra opgave 1
for at få dette til at fungere måtte vi foretage lidt ændringer i koden, de ses neden under

#ifndef SMARTSTRING_H
#define SMARTSTRING_H
#include <string>
using namespace std;
 
class SmartString
{
public:
  SmartString(string* str):str_(str), counter_(new unsigned int(1)){}
  ~SmartString()
  {
    (*counter_)--;
    if(!counter_)
    {
      delete str_;
      delete counter_;
    }
  }
 
  SmartString(const SmartString& other)
  {
    counter_ = other.counter_;
    str_ = other.str_;
    (*counter_)++;
  }
 
  SmartString& operator=(const SmartString& other)
  {
    if(this!= &other)
    {
      (counter_)--;
      {
      delete counter_;
      delete str_;
      }
    counter_ = other.counter_;
    str_ = other.str_;
    (counter_)++;
     }
 
     return *this;
 
  }
 
    string* get()
  {
     return str_;
  }
  string* operator->()
  {
    return str_;
  }
  string& operator*()
  {
    return *str_;
  }
 
private:
  /*Erklære copy construntor
   * og assignment
   * private, da vi ikke vil have andre til at pille ved copy og point
   */
  string* str_;
  unsigned int *counter_;
};
 
 
 
 
#endif
 

Del 3(Optional)


Del 4

 
#include <boost/shared_ptr.hpp>
 
int main ()
{
    boost::shared_ptr<std::string> stringPtr1(new std::string(" boost_ptr1"));
    boost::shared_ptr<std::string> stringPtr2(new std::string(" boost_ptr2"));
//vi opretter 2 string pointere der indeholder boost_ptr1 og boost_ptr2
 
    std::cout << *stringPtr1 << std::endl;
    std::cout << *stringPtr2 << std::endl;
// vi udskriver indholdet af de to strings ved at bruge overstående kode
 
    std::cout << stringPtr1.use_count() << std::endl;
//Udskriver use_count, den står på 1 her
 
    stringPtr2 = stringPtr1;
//tjekker at assignment operatoren virker
 
    std::cout << stringPtr1.use_count() << std::endl;
//Udskriver use_count, den står på 2 her
 
    std::cout << *stringPtr1 << "   " << *stringPtr2 << std::endl;
//tjekker ad der står det samme i stringPtr1 og 2
 
    boost::shared_ptr<std::string> stringPtr3(stringPtr1);
//Opretter en ny string hvor copy constructoren benyttes
 
    std::cout << stringPtr1.use_count() << std::endl;
//Udskriver use_count, den står på 3 her.
 
    std::cout << *stringPtr1 << "   " << *stringPtr3 << std::endl;
//tjekker at der står det samme i stringPtr1 og 3
 
    stringPtr2.reset();
//Vi deleter nu string2 for at tjekke counteren tæller ned igen
 
    std::cout << stringPtr1.use_count() << std::endl;
//Her er tælleren så talt ned til 2 igen.
 
    return 0;
}
 

Del 5
What do you consider a resource?

• Filer, CPU, Hukommelse

In which situations do you foresee challenges with resources and how would they be handled?

• I ens program kan man have problemer med at resources skal frigives igen, dette er en vigtig ing at huske
• Under vejs i programmet sker det at vi opretter flere udveje. Vi er derfor nød til at nedlægge disse i de situationer. De skal som hovedregel nedlægges af dem der laver dem.

In Particular regarding memory, when would you be able eliminate the need for allocations.
Or when is it a must that something is allocated (on heap)?

• Om vi arbejder med noget som vi ved præcist eller cirka hvor meget skal bruge af hukommelsen, altså noget statisk, i dette tilfælde kan vi gå ind og styre allokering og hukommelse.
• Om vi har behov for dynamisk at kunne allokere benytter vi heapen, dette er oftest ved nye objekter. Tilfældet kan også være at vi ikke kender størrelsen på det som vi skal allokere.